---
id: 594810f028c0303b75339ad6
title: Rappresentazione di Zeckendorf dei numeri
challengeType: 1
forumTopicId: 302346
dashedName: zeckendorf-number-representation
---

# --description--

Just as numbers can be represented in a positional notation as sums of multiples of the powers of ten (decimal) or two (binary); all the positive integers can be represented as the sum of one or zero times the distinct members of the Fibonacci series. Recall that the first six distinct Fibonacci numbers are: `1, 2, 3, 5, 8, 13`.

Il numero decimale undici può essere scritto come `0*13 + 1*8 + 0*5 + 1*3 + 0*2 + 0*1` o `010100` nella notazione posizionale in cui le colonne rappresentano la moltiplicazione per un particolare membro della sequenza. Gli zeri iniziali sono caduti in modo che 11 decimale diventa `10100`. 10100 non è l'unico modo per formare 11 dai numeri di Fibonacci: anche `0*13 + 1*8 + 0*5 + 0*3 + 1*2 + 1*1` o 010011 rappresenta il decimale 11. Per un vero numero di Zeckendorf c'è la restrizione che *non possono essere utilizzati due numeri consecutivi di Fibonacci* che porta alla precedente soluzione unica.

# --instructions--

Scrivi una funzione che genera e restituisce la rappresentazione di Zeckendorf del numero `n`.

# --hints--

`zeckendorf` dovrebbe essere una funzione.

```js
assert.equal(typeof zeckendorf, 'function');
```

`zeckendorf(0)` dovrebbe restituire `0`.

```js
assert.equal(zeckendorf(0), 0);

```

`zeckendorf(1)` dovrebbe restituire `1`.

```js
assert.equal(zeckendorf(1), 1);
```

`zeckendorf(2)` dovrebbe restituire `10`.

```js
assert.equal(zeckendorf(2), 10);
```

`zeckendorf(3)` dovrebbe restituire `100`.

```js
assert.equal(zeckendorf(3), 100);
```

`zeckendorf(4)` dovrebbe restituire `101`.

```js
assert.equal(zeckendorf(4), 101);
```

`zeckendorf(5)` dovrebbe restituire `1000`.

```js
assert.equal(zeckendorf(5), 1000);
```

`zeckendorf(6)` dovrebbe restituire `1001`.

```js
assert.equal(zeckendorf(6), 1001);
```

`zeckendorf(7)` dovrebbe restituire `1010`.

```js
assert.equal(zeckendorf(7), 1010);
```

`zeckendorf(8)` dovrebbe restituire `10000`.

```js
assert.equal(zeckendorf(8), 10000);
```

`zeckendorf(9)` dovrebbe restituire `10001`.

```js
assert.equal(zeckendorf(9), 10001);
```

`zeckendorf(10)` dovrebbe restituire `10010`.

```js
assert.equal(zeckendorf(10), 10010);
```

`zeckendorf(11)` dovrebbe restituire `10100`.

```js
assert.equal(zeckendorf(11), 10100);
```

`zeckendorf(12)` dovrebbe restituire `10101`.

```js
assert.equal(zeckendorf(12), 10101);
```

`zeckendorf(13)` dovrebbe restituire `100000`.

```js
assert.equal(zeckendorf(13), 100000);
```

`zeckendorf(14)` dovrebbe restituire `100001`.

```js
assert.equal(zeckendorf(14), 100001);
```

`zeckendorf(15)` dovrebbe restituire `100010`.

```js
assert.equal(zeckendorf(15), 100010);
```

`zeckendorf(16)` dovrebbe restituire `100100`.

```js
assert.equal(zeckendorf(16), 100100);
```

`zeckendorf(17)` dovrebbe restituire `100101`.

```js
assert.equal(zeckendorf(17), 100101);
```

`zeckendorf(18)` dovrebbe restituire `101000`.

```js
assert.equal(zeckendorf(18), 101000);
```

`zeckendorf(19)` dovrebbe restituire `101001`.

```js
assert.equal(zeckendorf(19), 101001);
```

`zeckendorf(20)` dovrebbe restituire `101010`.

```js
assert.equal(zeckendorf(20), 101010);
```

# --seed--

## --seed-contents--

```js
function zeckendorf(n) {

}
```

# --solutions--

```js
// zeckendorf :: Int -> Int
function zeckendorf(n) {
  const f = (m, x) => (m < x ? [m, 0] : [m - x, 1]);
  return parseInt((n === 0 ? ([0]) :
    mapAccumL(f, n, reverse(
      tail(fibUntil(n))
    ))[1]).join(''));
}

// fibUntil :: Int -> [Int]
let fibUntil = n => {
  const xs = [];
  until(
      ([a]) => a > n,
      ([a, b]) => (xs.push(a), [b, a + b]), [1, 1]
  );
  return xs;
};

let mapAccumL = (f, acc, xs) => (
  xs.reduce((a, x) => {
    const pair = f(a[0], x);

    return [pair[0], a[1].concat(pair[1])];
  }, [acc, []])
);

let until = (p, f, x) => {
  let v = x;
  while (!p(v)) v = f(v);
  return v;
};

const tail = xs => (
   xs.length ? xs.slice(1) : undefined
);

const reverse = xs => xs.slice(0).reverse();
```
